import Mock from "mockjs";


export const testFunctionCommon = {
    /**
     * 替换字符串中的 {{变量名}} 为环境变量的值
     * @param {string} str 可能包含 {{变量名}} 的字符串
     * @returns {string} 替换后的字符串
     */
    replaceVariables: (str,selectVariableList) => {
        if (!str || typeof str !== 'string') return str;

        return str.replace(/\{\{([^{}]+)\}\}/g, (match, variableName) => {
            const variable = selectVariableList.find(v => v.name === variableName.trim());
            return variable ? variable.value : match;
        });
    },

    /**
     * 处理对象中所有字符串值，替换其中的环境变量
     * @param {object} obj 需要处理的对象
     * @returns {object} 处理后的对象
     */
    processObjectVariables: (obj,selectVariableList) => {
        if (!obj || typeof obj !== 'object') return obj;

        const result = Array.isArray(obj) ? [...obj] : {...obj};

        Object.keys(result).forEach(key => {
            if (typeof result[key] === 'string') {
                result[key] = testFunctionCommon.replaceVariables(result[key],selectVariableList);
            } else if (typeof result[key] === 'object' && result[key] !== null) {
                result[key] = testFunctionCommon.processObjectVariables(result[key],selectVariableList);
            }
        });

        return result;
    },

    /**
     * 数据转换，并处理环境变量
     * @param {Array} data 参数数组
     * @returns {object|null} 转换后的对象
     */
    transData: (data, selectVariableList) => {
        if (!data || !Array.isArray(data)) return null;

        const newData = {};
        data.forEach(({ paramName, value }) => {
            if (paramName !== undefined) {
                // 替换可能的环境变量，然后使用 Mock 处理
                const processedValue = testFunctionCommon.replaceVariables(value, selectVariableList);
                newData[paramName] = Mock.mock(processedValue);
            }
        });

        return Object.keys(newData).length > 0 ? newData : null;
    },

    /**
     * header数据转换，并处理环境变量
     * @param {Array} data header数据数组
     * @returns {object} 转换后的header对象
     */
    headerData: (data, selectVariableList) => {
        if (!data || !Array.isArray(data)) return {};

        const headers = {};
        data.forEach(({ headerName, value }) => {
            if (headerName) {
                // 替换可能的环境变量，然后使用 Mock 处理
                const processedValue = testFunctionCommon.replaceVariables(value, selectVariableList);
                headers[headerName] = Mock.mock(processedValue);
            }
        });

        return headers;
    },

    /**
     * 表单数据转换
     * @param {object} data 表单数据对象
     * @returns {FormData} 转换后的FormData对象
     */
    formData: (data, selectVariableList) => {
        if (!data || typeof data !== 'object') return new FormData();

        // 先处理环境变量
        const processedData = testFunctionCommon.processObjectVariables(data, selectVariableList);

        const param = new FormData();
        for (const key of Object.keys(processedData)) {
            param.append(key, processedData[key]);
        }
        return param;
    },

    /**
     * 断言数据转换，并处理环境变量
     * @param {Array} data 断言数据数组
     * @returns {object|null} 转换后的断言对象
     */
    assertData: (data, selectVariableList) => {
        if (!data || !Array.isArray(data)) return null;

        const newData = {};
        data.forEach((item) => {
            const { source, propertyName, comparator, value } = item;
            if (source !== undefined) {
                // 替换可能的环境变量
                newData[source] = testFunctionCommon.replaceVariables(value, selectVariableList);
            }
        });

        return Object.keys(newData).length > 0 ? newData : null;
    },
};


//保存用例公共方法
export const saveTestcaseCommon ={
    filterData:(data)=>{
        data&&data.filter(item=>{
            let itemKeys = Object.keys(item);
            return !(itemKeys.length === 1 && itemKeys[0] === "id")
        })
    }
}


/**
 * jsonSchema转换成json
 */
export const jsonSchemaToJson = (schema, selectVariableList=[]) => {
    const result = {};

    if(!schema){
        return result
    }

    for (const key in schema.properties) {
        const property = schema.properties[key];

        if (property.type === 'object') {
            result[key] = jsonSchemaToJson(property);
        } else if (property.type === 'array') {
            const itemSchema = property.properties.ITEMS;
            const itemCount = Math.floor(Math.random() * 3) + 1; // 生成1到3个随机项
            result[key] = Array.from({ length: itemCount }, () => jsonSchemaToJson(itemSchema));
        } else {
            if(property.mock){
                const processedValue = testFunctionCommon.replaceVariables(property.mock.mock, selectVariableList);
                result[key] = processedValue;
            }else {

                result[key] = "@"+property.type
            }
        }
    }

    return result;
};
